console.log('只剩下demo1了');
/* 
class类当中的问题

1. class的写法
    构造器当中怎么写（new实例对象时，new出来的实例对象中包含构造器constructor当中的属性或者方法）
    原型对象上的方法
    class类本自身上的方法怎么添加
2. 继承
3. ts当中写这些东西，时时刻刻要考虑一个问题，就是如何设计它的数据类型
4. ts当时class类定义数据类型时使用接口进行定义，如何定义
5. 接口在class类当中的用法
*/

// 在ts当中 但凡遇见变量都要给他设计数据类型
class Animal{
    // 声明一下构造器当中的属性的数据类型
    name:string;
    age:number;
    // 构造器
    constructor(name,age){
        this.name=name;
        this.age=age;
    }
    // 这样直接添加到了实例对象上
    sex:string='babysheep'
    // 添加到了原型对象上
    // 函数规定数据类型就两个方向：一类是形参的数据类型  一类是函数返回值的数据 一类是函数返回值的数据（return后面的值 没有return时 返回的就是undefined）
    jump(str:string):void{
        console.log('跳了一下');
    }
    run(){
        console.log('跑了');
    }
    static song(){
        console.log('咩咩')
    }
    static color='white';
}
let sheep=new Animal('sheep',12);
console.log(sheep);
sheep.jump('小羊');
sheep.run();
let Dog=new Animal('Dog',3);
console.log(Dog);
console.log(Animal);
Animal.song();
console.log(Animal.color);
/*
原型对象  该对象上的方法和属性如何添加上去 如何调用执行
实例对象   该对象上的方法和属性如何添加上去 如何调用执行
构造函数（class本身）该对象上的方法和属性如何添加上去 如何调用执行

继承  父亲---儿子 继承
父类---子类  继承

Animal父类或者基类  超类
Person 子类 派生类
继承通过extends
通过super得到 super作为对象 作为函数
*/

class Person extends Animal{
    constructor(name:string,age:number){
        // 作为函数存在执行
        super(name,age)
    }
    // 原型对象
    // 子类原型对象上只能去继承父类原型对象上的方法，不能去继承父类自身上的方法
    jump(str: string): void {
        super.jump(str)
    }
    // class类自身
    static song():any{
        super.song()
    }
}
let xiaoxiao=new Person('xiaoxiao',123);
console.log(xiaoxiao);

// 修饰符
// public 公开 哪里都能看能用 内部外部都能使用  默认就是公开的
// private  私有的  只能内部访问外部不能访问,子类当中也不能访问
// protected 受保护   内部能访问 子类当中能访问外部访问
// readonly 只读  只能在属性声明或者构造函数里进行初始化
class xiaoyang{
    public name:string;
    private age:number;
    protected sex:string;
    readonly hobby:string;
    constructor(name:string,age:number,sex:string,hobby:string){
        this.name=name;
        this.age=age;
        this.sex=sex;
        this.hobby=hobby;
    }
    // 原型对象 操作这些属性名 在class内部进行操作
    show():void{
        // 内部
        console.log(this.name);
        console.log(this.age);
        console.log(this.sex);
    }
}
let white =new xiaoyang('宝宝',10,'男','打篮球');
console.log(white);
// 原型对象上的方法要使用 通过实例去调用
white.show();
// 外部访问
console.log(white.name);

class yangyang extends xiaoyang{
    constructor(name:string,age:number,sex:string,hobby:string){
        super(name,age,sex,hobby);
    }
    // 原型对象上的方法
    test():void{
        console.log(this.sex);  //受保护的
    }
}
let wen =new yangyang('好好',18,'男','看电视');
console.log(wen);
wen.test();
// console.log(sex())
console.log(wen.hobby);

// 参数属性
class xiaoli{
    // 对构造器中的属性进行类型规定
    // name:string;
    // age:number;
    constructor(public name:string,public age:number){
        this.name=name;
        this.age=age;
    }
}
let lili =new xiaoli('lili',19);
console.log(lili);

// 存取器 get set 获取触发get 更改触发set
class zhilong{
    name:string='志龙';
    hobby:string='吃饭睡觉打豆豆';
    // get读取值
    get zlh():string{
        return this.name+this.hobby;
    }
    // 当该值更改时就会触发set 触发set之后 获取新值 可以根据逻辑进行操作
    set zlh(value){
        console.log(value)
    }
}
// let xiaozhilong=new zhilong('sizhe','民风淳朴');
let xiaozhilong=new zhilong();
console.log(xiaozhilong.zlh);
xiaozhilong.zlh=('肤白貌美')

/* 抽象类
抽象类不能创建实例 它包含的都是一些抽象的方法 主要是为子类做父类用的
*/
abstract class Parent{
    abstract run();
    abstract jump();
}
class Son extends Parent{
    run(){
        console.log('子类当中的跑')
    }
    jump() {
        console.log('子类当中的跳')
    }
}
let danny = new Son();
danny.run();
danny.jump();

/* 
多态  父类型的引用指向了子类型的对象 不同类型的对象针对相同的方法  产生不同的行为
*/
// bird是父类 littlebird是子类  littlebird1是另一个子类
class bird{
    name:string;
    age:number
    constructor(name:string,age:number){
        this.name=name;
        this.age=age
    }
    // 原型对象上的方法
    jump(fly:number):string{
        return `${this.name}跳${fly}米`
    }
}

class littlebird extends bird{
    constructor(name:string,age:number){
        super(name,age)
    }
    // jump 在其中继承父类原型对象上的jump super.jump()
    jump(fly: number): string {
        return super.jump(fly)
    }
}

class littlebird1 extends bird{
    constructor(name:string,age:number){
        super(name,age)
    }
    // jump 在其中继承父类原型对象上的jump super.jump()
    jump(fly: number): string {
        return super.jump(fly)
    }
}

// 创建实例对象
// 不同类型的对象针对相同的方法，产生了不同的行为 这个现象称为多态
let Bird:bird=new bird('Bird',10);
console.log(Bird);
console.log(Bird.jump(40));

let Littlebird:bird=new bird('Littlebird',11);
console.log(Littlebird);
console.log(Littlebird.jump(55));

let Littlebird1:bird=new bird('Littlebird1',12);
console.log(Littlebird1);
console.log(Littlebird1.jump(60));
